import java.util.concurrent.atomic.AtomicBoolean;

/**
 * @description: Synchronized属于悲观锁，悲观地认为程序中的并发情况严重，所以严防死守。
 * CAS属于乐观锁，乐观地认为程序中的并发情况不那么严重，所以让线程不断去尝试更新。
 * @author: zys
 * @create: 2020-10-12 15:12
 **/
public class TestAtomicBoolean implements Runnable {

    private static AtomicBoolean flag = new AtomicBoolean(true);

    /**
     * CAS算法是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，
     * 也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking Synchronization）
     * <p> 需要读写的内存值 V 进行比较的值 A 拟写入的新值 B ABA 自旋
     * 这里无论怎么运行，Thread-1、Thread-0都会执行if=true条件，
     * 而且还不会产生线程脏读脏写，这是如何做到的了，
     * 用到了compareAndSet(boolean expect,boolean update)方法
     */
    public static void main(String[] args) {
        TestAtomicBoolean ast = new TestAtomicBoolean();
        Thread thread1 = new Thread(ast);
        Thread thread = new Thread(ast);
        thread1.start();
        thread.start();
    }

    @Override
    public void run() {
        System.out.println("thread:" + Thread.currentThread().getName() + ";flag:" + flag.get());
        if (flag.compareAndSet(true, false)) {
            System.out.println(Thread.currentThread().getName() + "" + flag.get());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag.set(true);
        } else {
            System.out.println("重试机制thread:" + Thread.currentThread().getName() + ";flag:" + flag.get());
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            run();
        }
    }

}
